{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#所有需求\n",
    "查药的五行 ok了\n",
    "药剂量的统计,最大药物用量,平均\n",
    "6经用药对比统计,尤其是阳证和阴证的对比图\n",
    "\n",
    "度量的转化\n",
    "桂枝系,四逆系的统计\n",
    "一个模糊查询,就是查一个关键字在任何地方"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#一些适合自己的药\n",
    "理中丸+附子,这个基本就是附子理中丸\n",
    "\n",
    "\n",
    "#自己瞎做的一些药\n",
    "但我想做的一个药是这样:\n",
    "四逆汤+大枣+芍药,那这个东西基本就是桂枝去桂加附子汤(有这个汤吗?好像并没有)\n",
    "但是在伤寒里,桂枝汤+四逆汤 各种相互加减的非常多,基本上桂枝汤+附子也就内含四逆汤了,所以这个组合在伤寒里非常常见,到处都是\n",
    "思路基本是:\n",
    "附子快速提阳,中土加固(比四逆汤更加固,加大枣以更好生津液),最后加上芍药,这是因为此时并不是救急的时期,而是慢性病去病根的时候,需要芍药配合大枣把津液给守住,存起来.基本就是这个套路.当然加上人参什么的也是可以的.我没钱所以就不加人参了.\n",
    "\n",
    "那么总结起来,就是固中土生津液的东西,再加上少量扶阳,再加上更少量收敛之药,可以是一个长时间服用的养生之药,适合现代那些亚健康和工作繁重以及压力大的人.(觉得基本现代城市人都适合,因为现代生活方式就是以极大消耗阳气换来所谓幸福的生活方式,那么基本就是这个药.)\n",
    "\n",
    "还有一个:\n",
    "四逆加龙骨牡蛎汤\n",
    "理论是让人在温暖中沉沉睡去,让好的睡眠去管理阴阳的中和,去升阳,去升阴\n",
    "我觉得深度良好的睡眠是世界上最大最好的医生\n",
    "睡眠很简单,就是人一生当中被动的\"恬淡虚无\"\n",
    "此时正是无为而治,这个整体无为的状态下,人体自动进入一种神奇的治疗,平衡,修复模式,人体自己制造的药(人体各种激素)比张仲景的要好太多了,张仲景也是明白这个事,所以用最小的干预身体的方式,让身体自己解决问题.\n",
    "\n",
    "\n",
    "#关于药的使用量\n",
    "我觉得,如果励志做一个好医生的话,不能轻信任何方剂,都要自己试,不自己试药,就不要做医生."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#不解的问题\n",
    "太阳病的很多方子,尤其是开始的几个,怎么写了很多多少两,多少株呢?\n",
    "写那几株真的有意义吗?\n",
    "而且为什么后文就再也没有这个写法了呢?\n",
    "真的很奇怪.\n",
    "\n",
    "只出现在\n",
    "桂枝麻黄各半汤\n",
    "桂枝二麻黄一汤\n",
    "\n",
    "什么情况?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#试图还原大系统和小系统的运作\n",
    "\n",
    "伤寒里是从阳引阴,我理解就是先要有阳气的力道,这力道温暖了脾胃,使其恢复运化功能,运化功能正常了,就可以良好的生津液.\n",
    "有点像是,先要重现太阳,然后给冰冻的土地解冻,解冻了,自然液态水就出现了.\n",
    "人体的小系统还是要从地球,太阳,月亮这个大系统去找,绝对不能脱离这个大系统.\n",
    "\n",
    "生命的关键是液态水,这个是第一大前提.\n",
    "而保证液态水的第一要素就是有一个温度适中的太阳,不能太热,把水蒸发,不能太冷,把水冰冻.\n",
    "我觉得仲景老师也是遵循着这个大系统的前提来研究人体小系统的.\n",
    "\n",
    "液态水就是伤寒里经常提的津液,人体里70%的物质.\n",
    "这个津液可以携带能量,就是有携带阳气的功能.\n",
    "也可以携带营养物质,就是携带阴的功能,这些津液循环于身体各处,就是这样将阴阳送达各处,将能量和营养送到各处.\n",
    "液态水需要一个温暖的太阳,一个不冻僵的土地来承载.\n",
    "所以仲景的方子,最大的两个方向就是,一个木,一个土.\n",
    "一个春天的方向,一个守中的方向.\n",
    "因为这两个方向可以直接导致一个良好的液态水的环境,不蒸发,不冰冻.\n",
    "蒸发了就是热证,冰冻了就是阴证.\n",
    "\n",
    "现代社会大部分是阴证,而且是表面上看起来一派火相,实际内部已经阴寒万分,那一点火是身体用来自保的家底子,现在人认虚火就是所谓的幸福.悲哉.\n",
    "\n",
    "阳证的话就要从外治,所以三阳病的药几乎是桂枝系,阴证从里治,阴证药附子和干姜就多了起来,先把里面给热起来.\n",
    "\n",
    "前天是双11,这两天亦是严重的雾霾.\n",
    "并不是双11直接导致雾霾,而是当下的一切以调动人们的欲望,调动那仅剩下的虚火来获利.\n",
    "地球上人们的欲望被史无前例的调动,那么地球是最终买单的人,因为造出这么多东西总不是从天上掉下来的.\n",
    "\n",
    "所以地球看起来一片繁荣一片火热,可是能量已经被严重消耗了,虚火的状态就是人越虚弱越需要打鸡血,于是一个自我毁灭的循环就在这里了.\n",
    "不是别的毁灭了地球,正是那些公司炫耀的每年多少亿的销量成绩单和背后的公司年报毁灭了地球.\n",
    "\n",
    "#关于先天和后天\n",
    "这个做在游戏里特别好,其实大表哥2的那个生存系统就很有这个意思.\n",
    "显示损耗的后天资本,后天的损耗完了,开始损耗先天的.\n",
    "而先天的损耗后,那么后天的恢复就会变慢.\n",
    "这就是看生病的津液调动是不是入了阴,我觉得阴证基本上就是伤先天的,阳证是后天的.\n",
    "病久久不治,都会转阴证.\n",
    "这里好好想一下,弄一个清晰明白的\"生病系统\",做在游戏里会非常好.\n",
    "\n",
    "不管先天,后天,阴和阳最终都是一,这个必须弄明白.但就是这个,人很难弄明白.\n",
    "游戏的系统里也必须做明白.\n",
    "游戏里需要有老死这个东西,病死这个东西.\n",
    "基本上学伤寒是学了老祖宗给设计的游戏核心玩法.......\n",
    "中国古道家,掌握了本沙盒宇宙游戏的核心API和核心玩法......\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#小日志\n",
    "今天捣鼓出来了一些基本的,也是重要的数据统计和图\n",
    "就是这些货"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import sys\n",
    "import pandas as pd\n",
    "import numpy as np\n",
    "import collections\n",
    "\n",
    "import matplotlib.mlab as mlab  \n",
    "import matplotlib.pyplot as plt\n",
    "from pylab import mpl\n",
    "\n",
    "from matplotlib import font_manager as fm\n",
    "from  matplotlib import cm"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "mpl.rcParams['font.sans-serif'] = ['STSong'] # 指定默认字体 如果在自己机器上运行可能需要修改这里\n",
    "mpl.rcParams['axes.unicode_minus'] = False # 解决保存图像是负号'-'显示为方块的问题"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Shanghan():\n",
    "    def __init__(self):\n",
    "        self.sh1 = pd.read_json('data/SH_ty2.json')\n",
    "        self.wx1 = pd.read_json('data/WX_yao.json')\n",
    "        self.wx = {y: sx for sx, yao in self.wx1.loc[\"药物\"].iteritems() for y in yao}\n",
    "        \n",
    "    def count_fang(self,fang):\n",
    "        a = self.sh1.loc['名'].str.match(fang).sum()\n",
    "        print(a)\n",
    "        \n",
    "    def count_fang_all(self):\n",
    "        plt.style.use('fivethirtyeight')#这个图的设定字体很清晰\n",
    "        plt.rcParams['figure.figsize'] = [18,13]\n",
    "        #plt.xlabel('药物')\n",
    "        plt.title(u'伤寒论重复方剂出现排名分析(前5名)', pad = 90)\n",
    "        plt.xticks(fontsize=25)#x轴的字体大小\n",
    "        plt.yticks(fontsize=30)\n",
    "        \n",
    "        l1 = {}\n",
    "        t_list = []\n",
    "        n_list = []\n",
    "        for i in self.sh1.loc['名'].items():\n",
    "            l1[i[1]] = self.sh1.loc['名'].str.match(i[1]).sum()\n",
    "        l2 = sorted(l1.items(),key = lambda item: item[1],reverse=True)#按照数值的大小排序\n",
    "        \n",
    "        for i in l2[:5]:\n",
    "            t_list.append(i[0])\n",
    "            n_list.append(i[1])\n",
    "            #plt.text(i[1],)\n",
    "        \n",
    "        x = np.arange(10)\n",
    "        ys = [i+x+(i*x)**2 for i in range(10)]\n",
    "        colors = cm.rainbow(np.linspace(0, 1, len(ys)))\n",
    "            \n",
    "        plt.bar(t_list,n_list,color=colors)\n",
    "        plt.show()\n",
    "        #print(l2)\n",
    "        \n",
    "    def count_yao(self,yao):\n",
    "        q1 = self.sh1.loc['方']\n",
    "        q2 = q1[q1.apply(lambda x:yao in x)].count()\n",
    "        print(q2)\n",
    "        \n",
    "    def count_yao_all(self):\n",
    "        q1 = self.sh1.loc['方']\n",
    "        l1 = {}\n",
    "        for i ,j in self.sh1.loc['方'].iteritems():\n",
    "            for g in j:\n",
    "                l1[g]= q1[q1.apply(lambda x:g in x)].count()\n",
    "        l2 = sorted(l1.items(),key = lambda item: item[1],reverse=True)\n",
    "                \n",
    "        print(l2)\n",
    "        \n",
    "    def draw_dir_all(self):#\n",
    "        plt.rcParams['figure.figsize'] = [18,13]\n",
    "        plt.style.use('fivethirtyeight')\n",
    "        \n",
    "        fang = self.sh1.loc['方']\n",
    "        sx = [self.wx.get(y,\"暂不明\") for f in fang for y in f]\n",
    "        sx_len = len(sx)\n",
    "        qq = {y: cnt / sx_len for y, cnt in collections.Counter(sx).items()}\n",
    "        qq1 = sorted(qq.items(),key = lambda item: item[1], reverse=True)\n",
    "        ss = {}\n",
    "        for i in qq1:#把list变成dict,为了画饼图\n",
    "            ss[i[0]]=i[1]\n",
    "        \n",
    "        #----------------下面是画饼图-----------------------------------\n",
    "        \n",
    "        labels = list(ss.keys())\n",
    "        X = list(ss.values())\n",
    "        fig, ax = plt.subplots(figsize=(18,13))\n",
    "        \n",
    "        colors = cm.rainbow(np.arange(len(X))/len(X))\n",
    "        patches, texts, autotexts = ax.pie(X, labels=labels, autopct='%1.2f%%',\n",
    "        shadow=False, startangle=170, colors=colors)\n",
    "        \n",
    "        proptease = fm.FontProperties()\n",
    "        proptease.set_size('x-large')\n",
    "        \n",
    "        plt.setp(autotexts, fontproperties=proptease)\n",
    "        plt.setp(texts, fontproperties=proptease)\n",
    "\n",
    "        plt.title(\"伤寒全部方剂五行方向图\", pad = 30)\n",
    "        plt.axis('equal')\n",
    "        plt.show()  \n",
    "        \n",
    "    def count_yao_all_draw(self):\n",
    "        plt.style.use('fivethirtyeight')#这个图的设定字体很清晰\n",
    "        plt.rcParams['figure.figsize'] = [18,13]\n",
    "        #plt.xlabel('药物')\n",
    "        plt.title('伤寒论药物用量排名分析(前10名)', pad = 90)\n",
    "        plt.xticks(fontsize=25)#x轴的字体大小\n",
    "        plt.yticks(fontsize=30)\n",
    "        plt.ylabel('该药在伤寒中出现次数(单位,次)')#y的描述\n",
    "        \n",
    "        \n",
    "        q1 = self.sh1.loc['方']\n",
    "        l1 = {}\n",
    "        t_list = []\n",
    "        n_list = []\n",
    "        for i ,j in self.sh1.loc['方'].iteritems():\n",
    "            for g in j:\n",
    "                l1[g]= q1[q1.apply(lambda x:g in x)].count()\n",
    "        l2 = sorted(l1.items(),key = lambda item: item[1],reverse=True)\n",
    "            \n",
    "        for i in l2[:10]:\n",
    "            t_list.append(i[0])\n",
    "            n_list.append(i[1])\n",
    "            #plt.text(i[1],)\n",
    "        \n",
    "        x = np.arange(10)\n",
    "        ys = [i+x+(i*x)**2 for i in range(10)]\n",
    "        colors = cm.rainbow(np.linspace(0, 1, len(ys)))\n",
    "            \n",
    "        plt.bar(t_list,n_list,color=colors)\n",
    "        plt.show()\n",
    "    \n",
    "    def find_fang(self, fang):\n",
    "        b = self.sh1.loc['名'].apply(lambda x: x)\n",
    "        c = b[b.apply(lambda x: fang == x)].index[0]\n",
    "        d = self.sh1[c]\n",
    "        print(d['名'])\n",
    "        print(\".........\")\n",
    "        print(str(pd.Series(d['经'])))\n",
    "        print(\".........\")\n",
    "        print(pd.Series(d['证']))\n",
    "        print(\".........\")\n",
    "        print(pd.Series(d['方']))\n",
    "        print(\".........\")\n",
    "        print(pd.Series(d['原文']))\n",
    "        \n",
    "    def bianzheng(self,zheng):#根据证输出对应方剂(简单根据伤寒的对应,而非根据心法)\n",
    "        #zheng这里要用大括号\n",
    "        a = self.sh1.loc['证'].apply(lambda x: set(x['体证']))\n",
    "        b = a[a.apply(lambda x: zheng <= x)].index\n",
    "        c = list(self.sh1[b].loc['名'])\n",
    "        \n",
    "        if c == []:\n",
    "            print(\"暂时没有找到\")\n",
    "        else:\n",
    "            print(\"找到如下方剂:\")\n",
    "            print(c)\n",
    "            \n",
    "    def draw_dir(self,f):\n",
    "        plt.rcParams['figure.figsize'] = [6,6]\n",
    "        plt.style.use('fivethirtyeight')#这个图的设定字体很清晰\n",
    "        \n",
    "        b = self.sh1.loc['名'].apply(lambda x: x)\n",
    "        c = b[b.apply(lambda x: f == x)].index[0]\n",
    "        d = self.sh1[c]\n",
    "        fang = d.loc['方']\n",
    "        sx = [self.wx.get(y, \"暂不明\") for y in fang]\n",
    "        fang_len = len(fang)\n",
    "        qq = {s: cnt / fang_len for s, cnt in collections.Counter(sx).items()}  #字典解析\n",
    "        \n",
    "        #----------------下面是画饼图-----------------------------------\n",
    "         \n",
    "        labels = list(qq.keys())\n",
    "        X = list(qq.values())\n",
    "        fig, ax = plt.subplots(figsize=(6,6))\n",
    "        \n",
    "        colors = cm.rainbow(np.arange(len(X))/len(X))\n",
    "        patches, texts, autotexts = ax.pie(X, labels=labels, autopct='%1.2f%%',\n",
    "        shadow=False, startangle=170, colors=colors)\n",
    "        \n",
    "        proptease = fm.FontProperties()\n",
    "        proptease.set_size('large')\n",
    "        \n",
    "        title = str(f)+'的五行方向图'\n",
    "        \n",
    "        plt.setp(autotexts, fontproperties=proptease)\n",
    "        plt.setp(texts, fontproperties=proptease)\n",
    "        \n",
    "        \n",
    "        plt.title(title, pad = 30)\n",
    "        plt.axis('equal')\n",
    "        plt.show()\n",
    "            \n",
    "        \n",
    "        \n",
    "        "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "b1 = Shanghan()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "小柴胡汤\n",
      ".........\n",
      "阴阳     阳\n",
      "三经    太阳\n",
      "dtype: object\n",
      ".........\n",
      "体证    [喜睡眠, 胸满胁痛]\n",
      "脉证           [脉细]\n",
      "dtype: object\n",
      ".........\n",
      "柴胡     0.5斤\n",
      "黄芩       3两\n",
      "人参       3两\n",
      "半夏     0.5升\n",
      "炙甘草      3两\n",
      "生姜       3两\n",
      "dtype: object\n",
      ".........\n",
      "对应证原文         [太阳病。十日以去。脉浮细而嗜卧者。外已解也。设胸满胁痛者。与小柴胡汤。]\n",
      "方剂原文     柴胡半斤 黄芩 人参 甘草[炙] 生姜各三两[切] 大枣十二枚[擘] 半夏半升[洗]\n",
      "服药原文            右七味。以水一斗二升。煮取六升。去滓。再煎。取三升。温服一升。日三服。\n",
      "dtype: object\n"
     ]
    }
   ],
   "source": [
    "b1.find_fang('小柴胡汤')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#基本上仲景的风格一览无余了,或者说是仲景的方向\n",
    "就是\"土木工程系\",土和木几乎相等,占了一半以上,是绝对的主方向\n",
    "所谓生命的方向了\n",
    "\n",
    "有趣的是,四逆汤的统计,四逆汤其实是重复用最多的,因为有通脉四逆汤就是四逆汤的姜多放了一些,其实四逆汤是重复用了8次,是仲景用的最多的方剂\n",
    "比大名鼎鼎的小柴胡都要多\n",
    "当然,要说最多应该是桂枝系,其次是四逆系,就是这样"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "通脉四逆汤\n",
      ".........\n",
      "阴阳     阴\n",
      "三经    少阴\n",
      "dtype: object\n",
      ".........\n",
      "体证    [四肢冷, 长期焦虑, 自感体虚, 长期抑郁, 没有精神, 总想睡觉]\n",
      "脉证                                   [暂无]\n",
      "dtype: object\n",
      ".........\n",
      "附子     1枚\n",
      "炙甘草    2两\n",
      "干姜     3两\n",
      "dtype: object\n",
      ".........\n",
      "对应证原文    [少阴病。下利清谷。里寒外热。手足厥逆。脉微欲绝。身反不恶寒。其人面色赤。或腹痛。或干呕。或...\n",
      "方剂原文                          甘草二两[炙] 干姜三两 附子一枚[生用 去皮 破八片]\n",
      "服药原文     右三味。以水三升。煮取一升二合。去滓。分温再服。其脉即出者愈。面色赤者。加葱九茎。腹中痛者。...\n",
      "dtype: object\n"
     ]
    }
   ],
   "source": [
    "b1.find_fang('通脉四逆汤')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "桂枝加附子汤\n",
      ".........\n",
      "阴阳     阳\n",
      "三经    太阳\n",
      "dtype: object\n",
      ".........\n",
      "体证    [大量出汗不止, 怕风, 小便难, 四肢难以屈伸]\n",
      "脉证                       [阳浮阴弱]\n",
      "dtype: object\n",
      ".........\n",
      "附子      1两\n",
      "桂枝      3两\n",
      "芍药      3两\n",
      "炙甘草     3两\n",
      "生姜      3两\n",
      "大枣     12枚\n",
      "dtype: object\n",
      ".........\n",
      "对应证原文          [太阳病，发汗，遂漏不止，其人恶风，小便难，四支微急，难以屈伸者，桂枝加附子汤主之。]\n",
      "方剂原文     桂枝三两,去皮,芍药三两,甘草二两,炙 生姜三两,切, 大枣十二枚,擘, 附子一枚,炮,去皮...\n",
      "服药原文              右六味。以水七升。煮取三升。去滓。温服一升。本云。桂枝汤。今加附子。将息如前法。\n",
      "dtype: object\n"
     ]
    }
   ],
   "source": [
    "b1.find_fang('桂枝加附子汤')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1296x936 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "b1.count_fang_all()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "忽然发现'桂枝加附子汤\"才是伤寒里使用最多的一个汤药,因为就是桂枝汤加一个附子,那么就是囊破了四逆汤和桂枝汤了"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1296x936 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "b1.count_yao_all_draw()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1296x936 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "b1.draw_dir_all()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![title](pic/p1.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "用这个来显示图片:\"![title](pic/p1.png)\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "最近一直在玩大表哥2,惊奇发现里面的生命系统已经非常接近古中医看待生命的理念了.\n",
    "\n",
    "所谓核心值,这个东西才能帮你恢复血,只要核心值ok,血就会顺利涨回阿里\n",
    "而核心值没有了,人就死了\n",
    "\n",
    "要伤害核心值必须要把外面那层血消耗掉才可以\n",
    "这不就是先天和后天吗\n",
    "\n",
    "中医管的就是那个核心值,核心值搞好了,所有病就自动消除了\n",
    "就这么简单\n",
    "\n",
    "大表哥这个游戏震惊了我了\n",
    "里面也有草药什么的\n",
    "\n",
    "而我需要扩展的就是这个生命系统和草药系统\n",
    "真正扩展成六经和五行这个东西"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.0"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}
